home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cpp_libs / rjs.lha / RJS / Regex / src / Regex.C < prev    next >
C/C++ Source or Header  |  1991-06-14  |  5KB  |  223 lines
  1. #include <RJS/String.h>
  2. #include "Regex.h"
  3.  
  4. #include "GNUregex.h"
  5. // Regex stuff
  6.  
  7.  RJS_Regex::RJS_Regex() 
  8. { 
  9.     compile_error="RE: not intialized"; 
  10.     buf=0;
  11.     reg=0;
  12.     changed=0;
  13. } 
  14.  
  15.  RJS_Regex::RJS_Regex(const RJS_Regex &re) : RJS_String(re.cptr())
  16. {
  17.   initialize(re.cptr(), re.length(), (int) re.buf->fastmap,re.buf->allocated,
  18.             re.buf->translate);
  19. }
  20.  
  21.  RJS_Regex::RJS_Regex(const RJS_String& s, int fast , int bufsize, 
  22.              const char* transtable ) : RJS_String(s)
  23. {
  24.   initialize(s.cptr(), s.length(), fast, bufsize, transtable);
  25. }
  26.  
  27.  RJS_Regex::RJS_Regex(const char *s, int fast, int bufsize, 
  28.              const char* transtable) : RJS_String(s)
  29. {
  30.   initialize(s, -1, fast, bufsize, transtable);
  31. }
  32.  
  33. RJS_Regex::~RJS_Regex()
  34. {
  35.   if (buf) {
  36.        delete(buf->buffer);
  37.        delete(buf->fastmap);
  38.   }
  39.   delete(buf);
  40.   delete(reg);
  41. }
  42.  
  43. void RJS_Regex::initialize(const char* t, int tlen, int fast, int bufsize, 
  44.                        const char* transtable)
  45. {
  46.   if (tlen < 0) tlen = RJS_String::length(t);
  47.   buf = new re_pattern_buffer;
  48.   reg = new re_registers;
  49.   if (fast)
  50.     buf->fastmap = new char[256];
  51.   else
  52.     buf->fastmap = 0;
  53.   buf->translate = (char*)transtable;
  54.   if (tlen > bufsize)
  55.     bufsize = tlen;
  56.   buf->allocated = bufsize;
  57.   buf->buffer = new char [buf->allocated];
  58.   compile_error=re_compile_pattern((char*)t, tlen, buf);
  59.   if (!compile_error) if (fast) re_compile_fastmap(buf);
  60.   changed=0;
  61. }
  62.  
  63. int RJS_Regex::match_info(int& start, int& length, int nth) const
  64. {
  65.   if ((unsigned)(nth) >= RE_NREGS)
  66.     return 0;
  67.   else
  68.   {
  69.     start = reg->start[nth];
  70.     length = reg->end[nth] - start;
  71.     return start >= 0 && length >= 0;
  72.   }
  73. }
  74.  
  75. int RJS_Regex::search(const char* s, int& matchlen, int len,int startpos) const
  76. {
  77.   int matchpos, pos, range;
  78.   if (changed) compile();
  79.   if (compile_error) { matchlen=0; return -1; }
  80.   if (len<0) len=RJS_String::length(s);
  81.   if (startpos >= 0)
  82.   {
  83.     pos = startpos;
  84.     range = len - startpos;
  85.   }
  86.   else
  87.   {
  88.     pos = len + startpos;
  89.     range = -pos;
  90.   }
  91.   matchpos = re_search_2(buf, 0, 0, (char*)s, len, pos, range, reg, len);
  92.   if (matchpos >= 0)
  93.     matchlen = reg->end[0] - reg->start[0];
  94.   else
  95.     matchlen = 0;
  96.   return matchpos;
  97. }
  98.  
  99. int RJS_Regex::search(const RJS_String & s, int& matchlen) const
  100. {
  101.   int matchpos, pos, range;
  102.   int len=s.length();
  103.   if (changed) compile();
  104.   if (compile_error) { matchlen=0; return -1; }
  105.   pos = 0;
  106.   range = len;
  107.   matchpos = re_search_2(buf, 0, 0, (char *) s.cptr(), len, pos, range, reg, len);
  108.   if (matchpos >= 0)
  109.     matchlen = reg->end[0] - reg->start[0];
  110.   else
  111.     matchlen = 0;
  112.   return matchpos;
  113. }
  114.  
  115. int RJS_Regex::match(const char *s, int len, int p) const
  116. {
  117.   if (changed) compile();
  118.   if (compile_error) { return 0; }
  119.   if (len<0) len=RJS_String::length(s);
  120.   if (p < 0)
  121.   {
  122.     p += len;
  123.     if (p >= len)
  124.       return 0;
  125.     return re_match_2(buf, 0, 0, (unsigned char*)s, p, 0, reg, p);
  126.   }
  127.   else if (p >= len)
  128.     return 0;
  129.   else
  130.     return re_match_2(buf, 0, 0, (unsigned char*)s, len, p, reg, len);
  131. }
  132.  
  133. int RJS_Regex::match(const RJS_String &s) const
  134. {
  135.   int len=s.length();
  136.   if (changed) compile();
  137.   if (compile_error) { return 0; }
  138.   if (len==0) return 0;
  139.   return re_match_2(buf, 0, 0, (unsigned char*)s.cptr(), len, 0, reg, len);
  140. }
  141.  
  142. int RJS_Regex::compile()
  143. {
  144.   int fast    =  (int)buf->fastmap;
  145.   int alloc   = buf->allocated;
  146.   char *trans = buf->translate;
  147.  
  148.   if (buf) { 
  149.     delete(buf->buffer);
  150.     delete(buf->fastmap);
  151.   }
  152.   delete(buf);
  153.   delete(reg);
  154.  
  155.   initialize(cptr(),length(), fast, alloc,trans);
  156.  
  157.   return ok();
  158. }
  159.  
  160. void RJS_Regex::operator=(const RJS_Regex &re)
  161. {
  162.   if (buf) {
  163.       delete(buf->buffer);
  164.       delete(buf->fastmap);
  165.   }
  166.   delete(buf);
  167.   delete(reg);
  168.  
  169.    (RJS_String &) *this = (RJS_String &) (re);
  170.  
  171.    initialize(re.cptr(), re.length(), (int) re.buf->fastmap,re.buf->allocated,
  172.             re.buf->translate);
  173. }
  174.  
  175. void RJS_Regex::operator=(const char *s)
  176. {
  177.   if (buf) {
  178.      delete(buf->buffer);
  179.      delete(buf->fastmap);
  180.   }
  181.   delete(buf);
  182.   delete(reg);
  183.  
  184.    (RJS_String &) *this = s;
  185.   initialize(s, -1, 0,40,0); // SHOULD FIX!!! fast, bufsize, transtable);
  186. }
  187.  
  188. void RJS_Regex::operator=(const RJS_String &s)
  189. {
  190.   if (buf) {
  191.       delete(buf->buffer);
  192.       delete(buf->fastmap);
  193.   }
  194.   delete(buf);
  195.   delete(reg);
  196.  
  197.    (RJS_String &) *this = s;
  198.   initialize(s.cptr(), s.length(), 0,40,0); // fast, bufsize, transtable);
  199. }
  200.  
  201. int RJS_Regex::ok() const
  202. {
  203.   if (changed) compile();
  204.   int v = buf != 0;             // have a regex buf
  205.   v &= buf->buffer != 0;        // with a pat
  206.   return v && (compile_error==0);
  207. }
  208.  
  209. const RJS_Regex RXwhite("[ \n\t\r\v\f]+", 1);
  210. const RJS_Regex RXoptwhite("[ \n\t\r\v\f]*", 1);
  211. const RJS_Regex RXnonwhite("[^ \n\t\r\v\f]+", 1);
  212. const RJS_Regex RXint("-?[0-9]+", 1);
  213. const RJS_Regex RXdouble("-?\\(\\([0-9]+\\.[0-9]*\\)\\|\\([0-9]+\\)\\|\\(\\.[0-9]+\\)\\)\\([eE][---+]?[0-9]+\\)?", 1, 200);
  214. const RJS_Regex RXalpha("[A-Za-z]+", 1);
  215. const RJS_Regex RXlower("[a-z]+", 1);
  216. const RJS_Regex RXupper("[A-Z]+", 1);
  217. const RJS_Regex RXalphanum("[0-9A-Za-z]+", 1);
  218. const RJS_Regex RXid("[A-Za-z_][A-Za-z0-9_]*", 1);
  219. const RJS_Regex RXstr("\"[^\"]*\"",1);
  220. // RXstrq is a string with \" in it. returns string with \" included
  221. const RJS_Regex RXstrq("\"\\([^\"\\]\\|\\\\\"\\|\\\\\\)*\"",1); 
  222.  
  223.